import { fileURLToPath } from 'url'
import { dirname, join } from 'path' // 添加join导入
import fs from 'fs'
import { app } from 'electron' // 导入Electron的app模块
import { BrowserWindow } from 'electron'
import { appConfig } from '../config/app-config.js'

// 为 ES 模块提供__dirname和__filename
const __filename = fileURLToPath(import.meta.url)
const __dirname_local = dirname(__filename)
const windows = BrowserWindow.getAllWindows()

// 流配置管理
class StreamConfigManager {
  constructor() {
    // 使用Electron的用户数据目录存储配置文件，而不是应用安装目录
    // 这样即使在打包后也能正常读写配置
    // const userDataPath = app.getPath('userData')

    // 配置文件保存在用户数据目录
    this.configFile = join(appConfig.workspacePath, 'RtspConfig.json')

    // 预置配置文件仍从应用目录读取
    // this.presetConfigPath = join(__dirname_local, '../../preset-streams-config.json')

    this.streams = []
    this.loadConfig()
  }

  // 加载配置
  loadConfig() {
    try {
      if (fs.existsSync(this.configFile)) {
        const data = fs.readFileSync(this.configFile, 'utf8')
        this.streams = JSON.parse(data)
        console.log('流配置加载成功:', this.streams.length, '个配置')
      } else {
        console.log('流配置文件不存在，使用空配置')
      }
    } catch (error) {
      console.error('加载流配置失败:', error)
      this.streams = []
    }
  }

  // 导入预置配置
  // importPresetConfig() {
  //   try {
  //     if (fs.existsSync(this.presetConfigPath)) {
  //       const presetData = fs.readFileSync(this.presetConfigPath, 'utf8')
  //       const presetStreams = JSON.parse(presetData)

  //       // 检查并合并配置（避免重复）
  //       presetStreams.forEach((presetStream) => {
  //         const existingStream = this.streams.find((stream) => stream.name === presetStream.name)
  //         if (!existingStream) {
  //           // 为预置配置添加必要字段
  //           const newStream = {
  //             id: Date.now().toString() + Math.random().toString(36).substr(2, 5),
  //             name: presetStream.name,
  //             rtsp: presetStream.rtsp,
  //             port: presetStream.port || 8080,
  //             status: 'stopped',
  //             createdAt: new Date().toISOString()
  //           }
  //           this.streams.push(newStream)
  //         }
  //       })

  //       this.saveConfig()
  //       console.log('预置配置导入成功')
  //       return true
  //     } else {
  //       console.log('预置配置文件不存在')
  //       return false
  //     }
  //   } catch (error) {
  //     console.error('导入预置配置失败:', error)
  //     return false
  //   }
  // }

  // 重置为预置配置
  // resetToPresetConfig() {
  //   try {
  //     if (fs.existsSync(this.presetConfigPath)) {
  //       const presetData = fs.readFileSync(this.presetConfigPath, 'utf8')
  //       this.streams = JSON.parse(presetData)

  //       // 为所有配置添加必要字段
  //       this.streams = this.streams.map((stream) => ({
  //         id: stream.id || Date.now().toString() + Math.random().toString(36).substr(2, 5),
  //         name: stream.name,
  //         rtsp: stream.rtsp,
  //         hls: stream.hls,
  //         port: stream.port || 8080,
  //         status: 'stopped',
  //         createdAt: stream.createdAt || new Date().toISOString()
  //       }))

  //       this.saveConfig()
  //       console.log('已重置为预置配置')
  //       return true
  //     } else {
  //       console.log('预置配置文件不存在')
  //       return false
  //     }
  //   } catch (error) {
  //     console.error('重置为预置配置失败:', error)
  //     return false
  //   }
  // }
  // 添加流配置
  // 修改addStream方法，确保每个流都有唯一ID
  addStream(config) {

    console.log('streams:', this.streams)
    // this.loadConfig()
    // 检查编号、流名称、RTSP地址是否已存在

    let errMsg = ''

    if (this.streams.find((stream) => stream.id === config.id)) {
      errMsg += `流ID"${config.id}"已存在，请使用其他ID<br>`
    }

    if (this.streams.find((stream) => stream.name === config.name)) {
      errMsg += `流名称"${config.name}"已存在，请使用其他名称<br>`
    }

    if (this.streams.find((stream) => stream.rtsp === config.rtsp)) {
      errMsg += `RTSP地址"${config.rtsp}"已存在，请使用其他地址<br>`
    }
    if (errMsg) {
      throw new Error(`${errMsg}`)
    }

    // const existingStream = this.streams.find(
    //   (stream) =>
    //     stream.name === config.name || stream.rtsp === config.rtsp || stream.id === config.id
    // )
    // if (existingStream) {
    //   throw new Error(`编号、流名称或RTSP地址已存在`)
    // }

    const newStream = {
      // id: Date.now().toString() + Math.random().toString(36).substr(2, 5), // 生成唯一ID
      // id: config.id, // 生成唯一ID
      // name: config.name,
      // rtsp: config.rtsp,
      ...config,
      status: 'stopped',
      createdAt: new Date().toISOString()
    }

    this.streams.push(newStream)

    try {
      this.saveConfig()
      console.log('添加流配置:', newStream)
      return newStream
    } catch (error) {
      // 如果保存失败，回滚添加操作
      this.streams.pop()
      throw new Error(`保存配置失败: ${error.message}`)
    }
  }

  // 保存配置
  saveConfig() {
    try {
      // 确保配置目录存在
      // const configDir = require('path').dirname(this.configPath)
      // if (!require('fs').existsSync(configDir)) {
      //   require('fs').mkdirSync(configDir, { recursive: true })
      // }
      // 打印文件路径以供调试
      console.log('Saving config to:', this.configFile)
      require('fs').writeFileSync(this.configFile, JSON.stringify(this.streams, null, 2))
      // 通知前端配置已更改
      windows.forEach((window) => {
        window.webContents.send('addLog', `[INFO] 流配置已更改`)
      })
      console.log('流配置保存成功')
    } catch (error) {
      console.error('保存流配置失败:', error)
      windows.forEach((window) => {
        window.webContents.send('addLog', `[ERROR] 保存流配置失败: ${error.message}`)
      })
      throw error // 重新抛出错误以便上层处理
    }
  }

  // 更新流配置
  updateStream(config) {
    const stream = this.streams.find((stream) => stream.id === config.id)
    if (stream) {
      const updatedStream = {
        ...stream,
        ...config
      }
      this.streams[this.streams.indexOf(stream)] = updatedStream
      this.saveConfig()
      console.log('更新流配置:', updatedStream)
    } else {
      throw new Error(`流配置未找到: ${config.id}`)
    }
  }

  // 删除流配置
  deleteStream(id) {
    const streamIndex = this.streams.findIndex((stream) => stream.id === id)
    if (streamIndex !== -1) {
      const deletedStream = this.streams.splice(streamIndex, 1)[0]
      this.saveConfig()
      console.log('删除流配置:', deletedStream)
      return deletedStream
    } else {
      throw new Error(`流配置未找到: ${id}`)
    }
  }

  // 切换流状态
  // toggleStreamStatus(index) {
  //   if (index >= 0 && index < this.streams.length) {
  //     const stream = this.streams[index]
  //     stream.status = stream.status === 'running' ? 'stopped' : 'running'
  //     this.saveConfig()
  //     console.log('切换流状态:', stream.name, '->', stream.status)
  //     return stream
  //   }
  //   return null
  // }

  // 获取所有流配置
  getAllStreams() {
    return this.streams
  }

  // 获取单个流配置
  getStreamById(id) {
    const stream = this.streams.find((stream) => stream.id === id) || null
    return stream || null
  }

  // 将所有流配置设为停止状态
  setAllStreamsToStopped() {
    this.loadConfig()
    this.streams.forEach((stream) => {
      stream.status = 'stopped'
    })
    this.saveConfig()
    console.log(`所有流配置已设为停止状态: ${JSON.stringify(this.streams, null, 2)}`)
  }
}

export { StreamConfigManager }
